import {
	API_URL
} from '@/env';

import vue from 'vue';

import {router,RouterMount} from '@/common/router.js';

/**
 * 常量：接口消息结构--数据字段名称
 */
const RES_DATA_FIELD = 'data'; //存储数据的属性名称

/**
 * 常量：接口消息结构--信息字段名称
 */
const RES_INFO_FIELD = 'info'; //存储信息的属性名称
/**
 * 常量：接口消息结构--状态字段名称
 */
const RES_STATUS_FIELD = 'status'; //存储状态的属性名称
/**
 * 常量：接口消息结构--成功状态值
 */
const RES_STATUS_SUCCESS = 1;//成功的状态
/**
 * 常量:接口消息结构--失败状态值
 */
const RES_STATUS_FAIL = 0;//失败的状态

/**
 * 常量:接口消息结构--登陆异常状态值
 */
const RES_STATUS_UNUSUAL = -1;//失败的状态




export default class Request {
    
    config = {
        baseUrl: API_URL,
        header: {
            'content-type' : 'application/json; charset=UTF-8'
        },
        method:'GET',
        dataType:'json'
    }
    // 判断URL是否为绝对路径
    static posUrl(url) {
        return /(http|https):\/\/([\w.]+\/?)\S*/.test();
    }
    static addQueryString(params) {
    	let paramsData = ''
    	Object.keys(params).forEach(function(key) {
    		paramsData += key + '=' + encodeURIComponent(params[key]) + '&'
    	})
			console.log(paramsData,'paramsData');
    	return paramsData.substring(0, paramsData.length - 1)
    }
    /**
     * @property {Function} request 请求拦截器
     * @property {Function} response 响应拦截器
     * @type {{request: Request.interceptor.request, response: Request.interceptor.response}}
     */
    interceptor = {
    	/**
    	 * @param {Request~requestCallback} cb - 请求之前拦截,接收一个函数（config, cancel）=> {return config}。第一个参数为全局config,第二个参数为函数，调用则取消本次请求。
    	 */
    	request: (cb) => {
    		if (cb) {
    			this.requestBeforeFun = cb
    		}
    	},
    	/**
    	 * @param {Request~responseCallback} cb 响应拦截器，对响应数据做点什么
    	 * @param {Request~responseErrCallback} ecb 响应拦截器，对响应错误做点什么
    	 */
    	response: (cb, ecb) => {
    		if (cb && ecb) {
    			this.requestComFun = cb
    			this.requestComFail = ecb
    		}
    	}
    }
    requestBeforeFun(config) {
        return config
    }
    requestComFun(response) {
        return response
    }
    requestComFail(response) {
        return response
    }
    /**
     * 自定义验证器，如果返回true 则进入响应拦截器的响应成功函数(resolve)，否则进入响应拦截器的响应错误函数(reject)
     * @param { Number } statusCode - 请求响应体statusCode（只读）
     * @return { Boolean } 如果为true,则 resolve, 否则 reject
     */
    validateStatus(statusCode) {
        return statusCode === 200
    }
    /**
     * @Function
     * @param {Request~setConfigCallback} f - 设置全局默认配置
     */
    setConfig(f){
        this.config = f(this.config)
    }
    
    /**
     * @Functions
     * @param {Object} options - 请求配置项
     * @prop {String} options.url - 请求路径
     * @prop {Object} options.data - 请求参数
     * @prop {Object} [options.responseType = config.responseType] [text|arraybuffer] - 响应数据类型
     * @prop {Object} [options.dataType = config.dataType] - 如果设置为json，会尝试对返回的做一次 JSON.parse
     * @prop {Object} [options.header = config.header] - 请求header
     * @prop {Object} [options.method = config.method] - 请求方法
     * @return {Promis<unknown>}
     */
    async request(options = {}) {
        if (options.header) {
            var config = {
                headers: {
                    'Contet-Type' : options.header
                }
            }
        }
        options.baseUrl = this.config.baseUrl
        options.dataType = options.dataType || this.config.dataType
        options.url = options.url || ''
        options.data = options.data || {}
        options.params = options.params || {}
        options.header = options.header || this.config.header
        options.method = options.method || this.config.method
        options.custom = { ...this.config.custom,
            ...(options.custom || {})
        }
        return new Promise((resolve, reject) => {
            let next = true
            let hendleRe = {}
            options.complete = (response) => {
                response.config = hendleRe;
                if (response.statusCode == 200) {
                    let data = response.data;
                    switch (data[RES_STATUS_FIELD]) {
                        // 成功
                        case RES_STATUS_SUCCESS:
							console.log(data,'成功data数据')
							resolve(data);
                            return response;
						// 失败
                        case RES_STATUS_FAIL:
							console.log(data,'失败data数据')	
							resolve(data);
                            return response;
                        case RES_STATUS_UNUSUAL:
                            uni.showToast({
                                title: '用户信息过期，请重新登录',
                                icon: 'none',
                                duration: 3000,
                                success:function(){
                                    // 是否需要跳转回登录页面
                                    console.log('用户信息过期，请重新登录');
                                    setTimeout(() => {
                                        uni.redirectTo({
                                            url:'/pages/guest/login/index'
                                        })
                                    },3000)
                                }
                            })
                    }
                } else {
                    return uni.showToast({
                        title: '请求发生错误,状态码:' + response.statusCode,
                        icon: 'none'
                    })
                }
                
                // 成功
                // if (this.validateStatus(response.statusCode)) { 
                //     response = this.requestComFun(response)
                //     resolve(response.data)
                // } else if (401 === response.statusCode) {
                //     response = this.requestComFun(response)
                //     resolve(response.data)
                // } else if (500 === response.statusCode) {
                //     resolve(response.data)
                // } else {
                //     response = this.requestComFail(response)
                //     reject(response)
                // }
            }
            const cancel = (t = 'handle cancel', config = options) => {
                const err = {
                    errMsg:t,
                    config:config
                }
                reject(err)
                next = false
            }
            hendleRe = {...this.requestBeforeFun(options, cancel)}
            console.log(hendleRe,'hendleRe');
            const _config = {...hendleRe}
            if (!next) return
            delete _config.custom
            let mergeUrl = Request.posUrl(_config.url) ? _config.url : (_config.baseUrl + _config.url)
            if (JSON.stringify(_config.params) !== '{}') {
                const paramsH = Request.addQueryString(_config.params);
                mergeUrl += mergeUrl.indexOf('?') === -1 ? `?${paramsH}` : `&${paramsH}`
            }
            _config.url = mergeUrl
            // 丢给uni-app框架封装好的api接口。 就不用axios了。
            uni.request(_config)
        })
    }
    // 请求方式
    get(url, options = {}) {
    	return this.request({
    		url,
    		method: 'GET',
    		...options
    	})
    }
    post(url, data, options = {}) {
    	return this.request({
    		url,
    		data,
    		method: 'POST',
    		...options
    	})
    }
    
}